home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / valops.c < prev    next >
C/C++ Source or Header  |  1992-03-25  |  21KB  |  780 lines
  1. /* Perform non-arithmetic operations on values, for GDB.
  2.    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #include "defs.h"
  22. #include "param.h"
  23. #include "symtab.h"
  24. #include "value.h"
  25. #include "frame.h"
  26. #include "inferior.h"
  27.  
  28. #ifdef atarist
  29. extern int gcc_mshort;
  30. #endif
  31.  
  32.  
  33. /* Cast value ARG2 to type TYPE and return as a value.
  34.    More general than a C cast: accepts any two types of the same length,
  35.    and if ARG2 is an lvalue it can be cast into anything at all.  */
  36.  
  37. value
  38. value_cast (type, arg2)
  39.      struct type *type;
  40.      register value arg2;
  41. {
  42.   register enum type_code code1;
  43.   register enum type_code code2;
  44.   register int scalar;
  45.  
  46.   /* Coerce arrays but not enums.  Enums will work as-is
  47.      and coercing them would cause an infinite recursion.  */
  48.   if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_ENUM)
  49.     COERCE_ARRAY (arg2);
  50.  
  51.   code1 = TYPE_CODE (type);
  52.   code2 = TYPE_CODE (VALUE_TYPE (arg2));
  53.   scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
  54.         || code2 == TYPE_CODE_ENUM);
  55.  
  56.   if (code1 == TYPE_CODE_FLT && scalar)
  57.     return value_from_double (type, value_as_double (arg2));
  58.   else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM)
  59.        && (scalar || code2 == TYPE_CODE_PTR))
  60.     return value_from_long (type, value_as_long (arg2));
  61.   else if (TYPE_LENGTH (type) == TYPE_LENGTH (VALUE_TYPE (arg2)))
  62.     {
  63.       VALUE_TYPE (arg2) = type;
  64.       return arg2;
  65.     }
  66.   else if (VALUE_LVAL (arg2) == lval_memory)
  67.     return value_at (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2));
  68.   else if (code1 == TYPE_CODE_VOID)
  69.     {
  70.       return value_zero (builtin_type_void, not_lval);
  71.     }
  72.   else
  73.     error ("Invalid cast.");
  74. }
  75.  
  76. /* Create a value of type TYPE that is zero, and return it.  */
  77.  
  78. value
  79. value_zero (type, lv)
  80.      struct type *type;
  81.      enum lval_type lv;
  82. {
  83.   register value val = allocate_value (type);
  84.  
  85.   bzero (VALUE_CONTENTS (val), TYPE_LENGTH (type));
  86.   VALUE_LVAL (val) = lv;
  87.  
  88.   return val;
  89. }
  90.  
  91. /* Return the value with a specified type located at specified address.  */
  92.  
  93. value
  94. value_at (type, addr)
  95.      struct type *type;
  96.      CORE_ADDR addr;
  97. {
  98.   register value val = allocate_value (type);
  99.  
  100.   read_memory (addr, VALUE_CONTENTS (val), TYPE_LENGTH (type));
  101.   VALUE_LVAL (val) = lval_memory;
  102.   VALUE_ADDRESS (val) = addr;
  103.  
  104.   return val;
  105. }
  106.  
  107. /* Store the contents of FROMVAL into the location of TOVAL.
  108.    Return a new value with the location of TOVAL and contents of FROMVAL.  */
  109.  
  110. value
  111. value_assign (toval, fromval)
  112.      register value toval, fromval;
  113. {
  114.   register struct type *type = VALUE_TYPE (toval);
  115.   register value val;
  116.   char raw_buffer[MAX_REGISTER_RAW_SIZE];
  117.   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
  118.   int use_buffer = 0;
  119.  
  120.   COERCE_ARRAY (fromval);
  121.  
  122.   if (VALUE_LVAL (toval) != lval_internalvar)
  123.     fromval = value_cast (type, fromval);
  124.  
  125.   /* If TOVAL is a special machine register requiring conversion
  126.      of program values to a special raw format,
  127.      convert FROMVAL's contents now, with result in `raw_buffer',
  128.      and set USE_BUFFER to the number of bytes to write.  */
  129.      
  130.   if (VALUE_REGNO (toval) >= 0
  131.       && REGISTER_CONVERTIBLE (VALUE_REGNO (toval)))
  132.     {
  133.       int regno = VALUE_REGNO (toval);
  134.       if (VALUE_TYPE (fromval) != REGISTER_VIRTUAL_TYPE (regno))
  135.     fromval = value_cast (REGISTER_VIRTUAL_TYPE (regno), fromval);
  136.       bcopy (VALUE_CONTENTS (fromval), virtual_buffer,
  137.          REGISTER_VIRTUAL_SIZE (regno));
  138.       REGISTER_CONVERT_TO_RAW (regno, virtual_buffer, raw_buffer);
  139.       use_buffer = REGISTER_RAW_SIZE (regno);
  140.     }
  141.  
  142.   switch (VALUE_LVAL (toval))
  143.     {
  144.     case lval_internalvar:
  145.       set_internalvar (VALUE_INTERNALVAR (toval), fromval);
  146.       break;
  147.  
  148.     case lval_internalvar_component:
  149.       set_internalvar_component (VALUE_INTERNALVAR (toval),
  150.                  VALUE_OFFSET (toval),
  151.                  VALUE_BITPOS (toval),
  152.                  VALUE_BITSIZE (toval),
  153.                  fromval);
  154.       break;
  155.  
  156.     case lval_memory:
  157.       if (VALUE_BITSIZE (toval))
  158.     {
  159.       int val;
  160.       read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  161.                &val, sizeof val);
  162.       modify_field (&val, value_as_long (fromval),
  163.             VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
  164.       write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  165.             &val, sizeof val);
  166.     }
  167.       else if (use_buffer)
  168.     write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  169.               raw_buffer, use_buffer);
  170.       else
  171.     write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  172.               VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
  173.       break;
  174.  
  175.     case lval_register:
  176.       if (VALUE_BITSIZE (toval))
  177.     {
  178.       int val;
  179.  
  180.       read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  181.                    &val, sizeof val);
  182.       modify_field (&val, value_as_long (fromval),
  183.             VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
  184.       write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  185.                 &val, sizeof val);
  186.     }
  187.       else if (use_buffer)
  188.     write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  189.                   raw_buffer, use_buffer);
  190.       else
  191.     write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  192.                   VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
  193.       break;
  194.  
  195.     default:
  196.       error ("Left side of = operation is not an lvalue.");
  197.     }
  198.  
  199. #if 1
  200.   /* Return a value just like TOVAL except with the contents of FROMVAL
  201.      (except in the case of the type if TOVAL is an internalvar).  */
  202.  
  203.   if (VALUE_LVAL (toval) == lval_internalvar
  204.       || VALUE_LVAL (toval) == lval_internalvar_component)
  205.     {
  206.       type = VALUE_TYPE (fromval);
  207.     }
  208.  
  209.   val = allocate_value (type);
  210.   bcopy (toval, val, VALUE_CONTENTS_RAW (val) - (char *) val);
  211.   bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS_RAW (val), TYPE_LENGTH (type));
  212.   VALUE_TYPE (val) = type;
  213.   
  214.   return val;
  215. #else
  216.   /* Return a value just like TOVAL except with the contents of FROMVAL.  */
  217.  
  218.   val = allocate_value (type);
  219.   bcopy (toval, val, VALUE_CONTENTS (val) - (char *) val);
  220.   bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
  221.  
  222.   return val;
  223. #endif
  224. }
  225.  
  226. /* Extend a value VAL to COUNT repetitions of its type.  */
  227.  
  228. value
  229. value_repeat (arg1, count)
  230.      value arg1;
  231.      int count;
  232. {
  233.   register value val;
  234.  
  235.   if (VALUE_LVAL (arg1) != lval_memory)
  236.     error ("Only values in memory can be extended with '@'.");
  237.   if (count < 1)
  238.     error ("Invalid number %d of repetitions.", count);
  239.  
  240.   val = allocate_repeat_value (VALUE_TYPE (arg1), count);
  241.  
  242.   read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
  243.            VALUE_CONTENTS (val),
  244.            TYPE_LENGTH (VALUE_TYPE (val)) * count);
  245.   VALUE_LVAL (val) = lval_memory;
  246.   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
  247.  
  248.   return val;
  249. }
  250.  
  251. value
  252. value_of_variable (var)
  253.      struct symbol *var;
  254. {
  255.   value val;
  256.  
  257.   val = read_var_value (var, (CORE_ADDR) 0);
  258.   if (val == 0)
  259.     error ("Address of symbol \"%s\" is unknown.", SYMBOL_NAME (var));
  260.   return val;
  261. }
  262.  
  263. /* Given a value which is an array, return a value which is
  264.    a pointer to its first element.  */
  265.  
  266. value
  267. value_coerce_array (arg1)
  268.      value arg1;
  269. {
  270.   register struct type *type;
  271.   register value val;
  272.  
  273.   if (VALUE_LVAL (arg1) != lval_memory)
  274.     error ("Attempt to take address of value not located in memory.");
  275.  
  276.   /* Get type of elements.  */
  277.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY)
  278.     type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1